Apps auf einem mobilen Gerät können selbst nur begrenzte Funktionalität bereitstellen. Sämtliche Ressourcen, von der Rechenkapazität bis zum Speicher, sind begrenzt. Ebenso verfügt man als Entwickler üblicherweise auch nicht über die notwendigen Daten. Es wurden schon zwei Beispiele genannt, die Anzeige des Wetters und die Fahrtzeiten des regionalen Stadtverkehrs. Dafür ortet die App zunächst den Standort des Nutzers, um dann passende Informationen kontextbezogen anbieten zu können. All diese Informationen und Funktionen werden von Clouddiensten über APIs zur Verfügung gestellt. In einigen Apps sind diese Funktionen ein netter Gimmick, in anderen kann ohne die Nutzung von APIs die Kernfunktion nicht vernünftig umgesetzt werden. Hier können wir zum Beispiel eine Shopping-App anführen, die über einen Dienstleister gängige Zahlungsmethoden anbietet. Es ist auch denkbar, dass man selbst eine interessante Funktion erstellt hat bzw. einen hilfreichen Service anbieten kann und diesen über ein eigenes API anbieten möchte, sodass andere Entwickler ihn nutzen. Im Folgenden geben wir einen praktischen Überblick über die Nutzung von APIs und zeigen gleichzeitig, dass das Hosten des eigenen Service in der Cloud heute kein Hexenwerk mehr sein muss.

Microservices als Basis

Die Verwendung von APIs führt zu einer anderen Applikationsarchitektur: die Aufteilung der Funktionen auf kleine, voneinander unabhängige Dienste, die sogenannte Microservices-Architektur. Diese Services können dabei flexibel durch unterschiedlichste Anwendungssysteme, die nicht nur auf das eigene Unternehmen beschränkt sind, benutzt werden. Die Integration erfolgt üblicherweise über RESTful HTTP, d. h. über eine einheitliche Schnittstelle. Die eigene Anwendung wird damit gewissermaßen zum Service, der sich wiederum aus der Nutzung anderer Dienste zusammensetzt. Wie muss man sich das vorstellen? Werfen Sie dazu einen Blick in Abbildung 1.

Eine Vielzahl von externen Services wird sinnvoll kombiniert und ggf. um weitere eigene Funktionen angereichert. Auf diese Weise muss man sich nur um seine Kernfunktion kümmern und kann zusätzliche Funktionen der App einbinden. Für die Nutzung eines Service spielt dessen technische Umsetzung keine Rolle. Verschiedene Betriebssysteme und die Bereitstellung auf gänzlich unterschiedlichen Technologien sind keine Hindernisse. Einzelne Services können ausgetauscht werden oder werden unabhängig vom Gesamtsystem aktualisiert. Sofern man Services von Drittanbietern nutzt, gibt man gewissermaßen die gesamte Verantwortung für den Betrieb und die künftige Entwicklung ab. Nutzt man beispielsweise in einer App das API eines Bezahldiensts, muss man sich lediglich mit der Nutzung des API über REST vertraut machen. Der Dienst wird nicht nur von uns verwendet, sondern von vielen weiteren Apps und Webseiten. Die Weiterentwicklung des Diensts steht vollständig in der Verantwortung des Anbieters. Sofern sich die Schnittstelle nicht ändert, haben Anpassungen am Dienst keine Auswirkungen auf unsere Software. Sind wir – aus welchen Gründen auch immer – nicht mehr mit den Leistungen des Diensts zufrieden, können wir ihn gegen einen anderen austauschen. Anpassungen sind nur an den Stellen des Quelltexts notwendig, die mit dem Dienst kommunizieren. Der wichtigste Grund zur Nutzung eines API besteht darin, dass man auf diese Weise den Zugang zu Diensten, Daten und Services bekommt, die man als Entwickler nicht selbst programmieren kann. Wir können keinen Bezahldienst im Stil von PayPal selbst einrichten, das Wetter von vielen tausend Orten aktuell bereitstellen oder Nachrichten aus unzähligen Quellen der ganzen Welt eigenständig abrufen. Mit anderen Worten: APIs eröffnen uns Entwicklern und unseren Apps und Webapplikationen den Zugang zu ganz neuen Möglichkeiten.

Natürlich hat die Nutzung von (öffentlichen) APIs auch einen Nachteil: Wir werden in gewisser Weise vom entsprechenden Dienst abhängig. Ändert der Anbieter das Serviceangebot in technischer Hinsicht, müssen wir die Änderungen nachvollziehen. Passt er die Preise oder das Abrechnungsmodell bzw. die Nutzungsbedingungen an, haben wir nur die Wahl, sie zu akzeptieren oder uns nach einem anderen Dienstleister umzusehen.

Dennoch: Der Einsatz von APIs ist die Voraussetzung für leistungsfähige Apps und interessante Funktionen. Erst dadurch sind wir in der Lage, bestimmte Funktionen sinnvoll zu kombinieren und den Nutzern Mehrwerte zu bieten.

Service für Entwickler

Viele Internet- und Clouddienstleister stellen Ihre Services für die erweiterte Nutzung zur Verfügung. Entwickler sind damit in der Lage, über ein API die Funktionen aus der eigenen App zu verwenden. Dazu gibt es meist einen Developerbereich mit der Möglichkeit, sich zu registrieren, und eine Dokumentation, wie das spezifische API des Anbieters zu nutzen ist. Neben der technischen Verwendung sind auch die Fragen der Bezahlung und der weiteren Nutzungsbedingungen zu klären. Sehen wir uns das an einigen Beispielen an:

• PayPal: Unter [2] findet man den Zugang zum Developerportal des Zahlungsdienstleisters PayPal. Aufgrund der hohen Reichweite und der guten Akzeptanz von PayPal kann es sinnvoll sein, diesen Dienst für die Abwicklung der eigenen Kundenzahlungen zu nutzen. Unter dem Punkt APIs finden Sie zum Beispiel die Beschreibung der generischen RESTful APIs zur Nutzung von PayPal aus der eigenen App oder Webapplikation heraus.

• Dropbox: Ebenso umfangreich sind die Angebote, die der cloudbasierte Speicherdienst Dropbox [3] Entwicklern macht. Es finden sich neben der Dokumentation des Webinterface auf Basis von REST/HTTP auch Hinweise zur direkten Nutzung aus einzelnen Programmiersprachen. Dabei wird meist auf Open-Source-Bibliotheken verwiesen, die die Schnittstellenkonventionen von Dropbox kapseln und in der jeweiligen Zielsprache wie .NET/C#, Java, Swift usw. bereitstellen. In diesen Fällen müssen Sie dann nicht mehr die RESTful APIs von Dropbox nutzen, sondern können ein angepasstes Software Development Kit (SDK) verwenden, das auf die Belange Ihrer Programmiersprache ausgerichtet ist. Über den Developerzugang kann man die Nutzung von Dropbox in die eigene App integrieren und darüber beispielsweise Dokumente oder Multimediadateien direkt in die Cloud hochladen.

• Twitter: Auch der Kurznachrichtendienst Twitter ermöglicht die Einbindung in eigene Apps und Webseiten durch ein generisches RESTful API. Man findet unter dem Menüpunkt Docs | API Reference Index die Beschreibung des API [4]. Damit sind Sie in der Lage, über Ihren Account direkt aus einer App oder einer Webapplikation die passenden Messages über Twitter abzusetzen.

Diese Aufzählung könnten wir beliebig fortsetzen. Sie sollten erkennen, dass viele bekannte Dienstleister ihre Services zur Nutzung über APIs zur Verfügung stellen. Vor der Verwendung sollten Sie sich mit den folgenden Fragen auseinandersetzen:

• Bedingungen: Unter welchen Bedingungen wird der Service angeboten? Eine Registrierung ist meist üblich, und zur Identifikation erhält man i. d. R. einen eindeutigen Key. Erlaubt der Dienst die Nutzung in der von mir vorgesehenen Art und Weise? Die Voraussetzungen zur Nutzung sind unbedingt zu beachten.

• Entgelte: In welcher Höhe und nach welchem Abrechnungsmodell fallen Nutzungsgebühren an? Oft ist eine bestimmte Anzahl von API-Aufrufen (Calls) kostenfrei. Überschreitet man bestimmte Freigrenzen, werden Entgelte fällig. Das ist insbesondere dann zu beachten, wenn das API aus einer stark frequentierten App genutzt wird. Bindet man beispielsweise den Abruf des aktuellen Wetterberichts in die eigene Buchungs-App für ein Freizeitangebot ein, wird bei jeder Buchungsanfrage das API kontaktiert. Die Freigrenze an Calls kann damit schnell überschritten werden. Es können in diesem Fall unerwünschte Kosten anfallen oder es kommt zur Fehlermeldung in der App, dass der Abruf der Daten wegen Überschreitung des Kontingents nicht mehr möglich ist.

• Schnittstelle: Die meisten Dienste sind über ein RESTful API zu erreichen, d. h., die Services werden über die üblichen Methoden wie GET, POST usw. (Kasten: „RESTful APIs“) zur Verfügung gestellt. Damit ist eine generische Verwendung über alle Systeme und Programmiersprachen hinweg möglich. Die Antwort des Dienstes erfolgt i. d. R. in Form eines Datenstroms, zum Beispiel im Format JSON. Dieser muss dann geparst (interpretiert) werden. Viele Dienste bieten darüber hinaus die Möglichkeit, alternativ ein SDK – angepasst an die System- und Entwicklungsumgebung – zu nutzen. Für häufige Verwendung finden Sie ein solches oft für .NET, Java oder PHP in Form einer Klassenbibliothek, die das RESTful API für die leichtere Verwendung kapselt. Wird ein solches SDK vom Dienst nicht angeboten, dann lohnt sich auf jeden Fall eine Recherche im Netz, zum Beispiel bei GitHub. Andere Entwickler haben das gleiche Problem mit dem betreffenden API vielleicht schon gehabt, gelöst und stellen die Lösung zur allgemeinen Nutzung zur Verfügung; die Verwendung einer fertigen Lösung spart viel Zeit.

• Datenschutz: Prüfen Sie, ob es zulässig ist, dass Sie Daten aus Ihrer App an einen Clouddienst senden. Die Einwilligung des Nutzers dürfte das Minimum an notwendigen Maßnahmen sein. Schon bei der simplen Übermittlung der Geoposition zur Abfrage der lokalen Wetterdaten brauchen Sie die Zustimmung Ihres Nutzers.

Nach dieser theoretischen Einführung in die Nutzung von APIs geben wir nun ein Überblick über Sammlungen und Auflistungen von API-Diensten.

RESTful APIs

Für die Nutzung eines RESTful API aus einer App oder Webapplikation muss man sich mit der Syntax der HTTP-basierten Abfrage für den jeweiligen Dienst beschäftigen. Ein Request (Anfrage) besteht aus vier Bestandteilen: Endpunkt (Endpoint), Methode (Method), Header und Daten (Body). Der Endpunkt setzt sich aus dem Root Endpoint, dem Path und möglichen Parametern zusammen. Der Endpunkt kann daher zum Beispiel lauten: https://www.5dayweather.org/api.php. Es können noch Parameter nach dem folgenden Muster angehängt werden: ?query1=value1&query2=value2. Setzt man das zusammen ergibt sich: https://www.5dayweather.org/api.php?city=Erfurt. Hier rufen wir die Wetterdaten für die Stadt Erfurt ab. Es wird genau ein Parameter benötigt. Bei den Methoden hat man die Wahl zwischen GET, POST, PUT/PATCH und DELETE. GET steht für Read-Operationen, also das Abfragen von Daten. Das dritte Element einer Anfrage ist der Header. Der Header dient zur Bereitstellung von Informationen für den Client und den Server. Er kann für viele Zwecke verwendet werden, zum Beispiel zur Authentifizierung. Als letztes Element folgen die Daten (Body), die man an den Server übermitteln möchte.

Wo gibt es das passende API?

Was man nicht kennt, kann man nicht nutzen. Das gilt auch für APIs. Eine umfassende Auflistung von öffentlich nutzbaren APIs findet man zum Beispiel unter https://any-api.com. Hier werden frei zugängliche Services aufgeführt, nach Kategorien sortiert und dokumentiert, und man kann viele davon gleich ausprobieren, also den betreffenden Endpunkt direkt mit eigenen oder vorgegebenen Testdaten aufrufen und das Ergebnis abfragen. Es finden sich für die unterschiedlichsten Bereiche entsprechende Services, zum Beispiel Analytics, Location, Transport usw. Für einige Services benötigt man einen Key, für den man sich i. d. R. auf der Seite des Diensts registrieren muss.

Eine ähnliche Übersicht über nutzbare APIs finden Sie auch unter https://www.programmableweb.com/apis/directory. Die Datensammlung ist umfangreich und man kann über Stichworte, zum Beispiel „Weather“, ausgewählte Dienste zu den entsprechenden Themen finden.

Zusammenfassend kann man also sagen: Um das passende API zu finden, ist etwas Detektivarbeit notwendig. Als erste Anlaufstelle dienen öffentliche Webdienste, die den gewünschten Service anbieten. Oft gibt es eine nutzbare Schnittstelle für Entwickler, um die eigene App anzubinden. Im Bereich allgemeiner Services wie KI-Diensten zur Bilderkennung, Sprachübersetzungen, Textanalysen usw. kann man bei den großen Cloudanbietern wie Amazon, Google, Microsoft und IBM prüfen, ob sie einen entsprechenden Dienst zur Nutzung via REST zur Verfügung stellen. Ist man noch nicht fündig geworden, kann man in den API-Katalogen nachschauen.

Praxisbeispiel

Nun möchten wir uns beispielhaft ansehen, wie man öffentlich nutzbare APIs ganz einfach verwenden kann, um Funktionalität in einer App bereitzustellen. Wir illustrieren das anhand sowohl eines Wetter- als auch eines Newsdiensts und probieren die Verwendung eines RESTful API in einer App für die Universal Windows Platform (UWP) aus. Als Programmiersprache verwenden wir C#. In anderen Sprachen und Systemen funktioniert es ähnlich.

Beginnen wir mit der Wetterabfrage, einem häufig einsetzbaren Feature. Als Dienst verwenden wir http://api.openweathermap.org, der unterschiedliche Daten zum Abruf anbietet. Diese unterscheiden sich nach Datenumfang und der Anzahl der vorhergesagten Tage. Auch die Anzahl der Calls in einem bestimmten Zeitintervall ist entscheidend. Aus diesen Parametern ergibt sich das Preismodell (Abb. 2)

.

Bereits die kostenfreie Variante (Free) ermöglicht 60 Calls pro Minute. Man kann alternativ zwischen dem aktuellen Wetter oder einer Vorhersage für fünf Tage im Drei-Stunden-Rhythmus wählen. Für die Nutzung benötigt man einen Key, den man nach der Registrierung beim Dienst erstellen kann.

Listing 1: Klasse „OpenWeatherMapProxyForecast“ zum Abrufen der Wetterdaten von „http://api.openweathermap.org“

namespace OpenWeatherForecast
{
  public class OpenWeatherMapProxyForecast
  {
    private const string apiKey = "Your Key here";
    private const string basisUri = "http://api.openweathermap.org/data/2.5/";
    private const string endPoint = "/forecast";
 
 
    public async static Task<RootObject> GetWeather(string location)
    {
      var httpClient = new HttpClient();
      string uri = basisUri + endPoint + "?q=" + location + "&appid=" + apiKey + "&units=metric";
      var response = await httpClient.GetAsync(uri);
      var result = await response.Content.ReadAsStringAsync();
      var serializer = new DataContractJsonSerializer(typeof(RootObject));
      var ms = new MemoryStream(Encoding.UTF8.GetBytes(result));
      var data = (RootObject)serializer.ReadObject(ms);
      return data;
    }
  }
 
  [DataContract]
  public class RootObject
  {
    [DataMember]
    public string cod { get; set; }
    [DataMember]
    public double message { get; set; }
    [DataMember]
    public int cnt { get; set; }
    [DataMember]
    public List<List> list { get; set; }
    [DataMember]
    public City city { get; set; }
  }
 
  [DataContract]
  public class Main
  {
    ...
  }
 
  [DataContract]
  public class Weather
  {
    ...
  }
   ...
   ...
}

Kommen wir zum Quellcode. Wir arbeiten in C# und .NET Core (UWP). Dazu erstellen wir eine eigene Klasse namens OpenWeatherMapProxyForecast (Listing 1). Initial definieren wir Konstanten für den Key, den Basis-URI und den Endpunkt. Den Datenabruf erledigen wir über eine eigene Methode (GetWeather), die wir asynchron ausführen. Das API liefert die Wetterdaten in Form eines JSON-Datenstroms. Dieser Datenstrom ist in eine Klassenstruktur zu deserialisieren. Dazu benötigen wir eine Klassenstruktur, die einen hierarchischen Aufbau beginnend mit der Klasse RootObject hat. Diese Klassenstruktur kann man selbst erstellen, oder man nutzt JSON-Daten, etwa aus der API-Dokumentation, und generiert die Datenstruktur automatisch, zum Beispiel mit Hilfe des Tools json2csharp [5] (Abb. 3).

Dazu kopiert man die JSON-Daten in das Textfeld und generiert die Klassen. Die wiederum sind die Basis für die Deserialisierung. Auf diese Weise haben wir die Daten vom Dienst per API abgerufen, die Wetterdaten liegen danach als Objekte der generierten Klassenstruktur vor und können verarbeitet werden. Zum Beispiel können wir sie als Basis für eine Wetter-App verwenden oder mit den Daten ergänzende Informationen im eigenen Programm bereitstellen. Wie man die Wetterdaten grafisch z. B. aufbereiten kann zeigt Abbildung 4.

Nach dem Wetter kommen wir zu den Nachrichten. Hier nutzen wir das API von https://newsapi.org. Dieser Dienst bietet Entwicklern über ein REST API den Zugang zu internationalen Nachrichten. Man kann u. a. nach Kategorien und Quellen filtern. Während wir bei der Nutzung des Wetter-API die Klassenstruktur und das REST-Interface noch selbst implementiert haben, wollen wir für das News-API eine fertige Klassenbibliothek verwenden. Auf der Webseite des Diensts werden SDKs für unterschiedliche Systeme angeboten, u. a. für Node.js, Ruby, Java und C#. Das C# SDK arbeitet mit dem .NET Framework, wir arbeiten jedoch mit der UWP und setzen deshalb auf .NET Core. Ein passender Wrapper für .NET Core und das News-API findet sich unter [6]. Diese Bibliothek kann man über NuGet als Package in das eigene .NET-Core-Projekt einbinden. Der Abruf der Daten gestaltet sich dann wirklich einfach. Auch für die Nutzung des News-API benötigen wir einen individuellen Key, den wir abermals nach der Registrierung beim Dienst erhalten. Das API sieht ein Abrufen der Daten nach den Kriterien „Top Headlines“ (Schlagzeilen), „Everything“ (Suche nach Artikeln über bestimmte Schlagwörter) und „Sources“ (Suche nach ausgewählten Quellen) vor, und das SDK kapselt diese Möglichkeiten. In Listing 2 zeigen wir das Abrufen der Headlines mit C# und .NET Core. Die Variable newsArticles enthält dann die abgerufenen Top-20-Schlagzeilen, u. a. mit den Items Headline, Source, Image und Description. Mit Hilfe dieses API können wir zum Beispiel ein Newsportal erstellen oder die Daten als Newsfeed in einer eigenen App anzeigen.

Listing 2: Abrufen der News über das News-API

using Hassie.NET.API.NewsAPI.API.v2;
using Hassie.NET.API.NewsAPI.Client;
using Hassie.NET.API.NewsAPI.Models;
...
 
namespace MyHome.ViewModels
{
  public class NewsControlViewModel : Observable
  {
    ...
    private async void GetNewsFromServiceAsync()
    {
      // https://github.com/hassie-dash/NewsAPI.NET
      INewsClient newsClient = new ClientBuilder()
      {
        ApiKey = "Your Key"
      }
      .Build();
      newsArticles = await newsClient.GetTopHeadlines(new TopHeadlinesBuilder()
        .WithCountryQuery(Country.DE)
        .WithLanguageQuery(Language.DE)
        .Build());
      ShowNewsArticle(currentNumber);
    }
 
   ...
  }
}

Die Arbeit mit den beiden vorgestellten APIs zeigt, wie einfach es ist, interessante Daten (wie das Wetter) oder Informationen (Schlagzeilen, Artikel) von entsprechenden Diensten abzurufen und der eigenen Applikation als Service zur Verfügung zu stellen.

Hallo Welt, hier kommt mein API

Bis jetzt befanden wir uns ausschließlich in der Rolle des Konsumenten. Natürlich kann man auch sein eigenes API zur allgemeinen Nutzung zur Verfügung stellen. Wir können hier keine vollständige Einführung in das API-Design geben, doch einige Denkanstöße, wie man starten könnte, sind möglich. Ein typischer Ansatz, gewissermaßen das manuelle Vorgehen, basiert auf dem Einsatz von JavaScript. Wir möchten ein minimales „Hello World“-API bauen. Dazu brauchen wir Node. js (min. Version 8) und npm (min. Version 5) sowie das Express Framework, das Sie wie folgt installieren:

npm init
npm install express body-parser

Werfen wir jetzt einen Blick in den Quellcode (Listing 3). Nach einigen Initialisierungen wird eine GET-Methode hello definiert. Wird sie über den Endpunkt http://localhost:5000/hello aufgerufen, gibt sie lediglich die Zeichenkette hello zurück. Diese einfache Methode demonstriert jedoch die Arbeitsweise eines API. An die Methode GET muss dann serverseitig die Businesslogik gebunden werden, die beim Aufruf über REST ausgelöst wird. Mit GET können nur lesende Operationen durchgeführt werden, d. h. man ruft Daten vom Dienst ab. Durch Methoden wie POST, PUT usw. können auch Daten vom Client an den Server übermittelt werden.

Listing 3: Ein Restful API mit Node.js und Express

const express = require('express');
const bodyParser = require('body-parser');
const app = express();
var router = express.Router();
app.use(bodyParser.urlencoded({
  extended: false
}));
 
app.get('/hello', (req, res) => {
  res.json({
    message: 'hello'
  });
});

Durch Tools einfacher

Ein eigenes API zu hosten, kann aufwendig sein. Serverseitig sind einige Installationen und Konfigurationen notwendig. Ebenso muss man die Logik auf den Server bekommen. Mit Hilfe von Tools kann man den Aufwand minimieren. Einen eigenen Server kann man zum Beispiel mit RAD Server sehr leicht aufsetzen. Um das auszuprobieren, benötigen Sie eine Testversion von RAD Studio Enterprise Edition [7]. Wir arbeiten auf der Ebene der Konfiguration, d. h. die meisten Einstellungen können wir mit Hilfe von Dialogen vornehmen. Der dazu notwendige Quellcode wird automatisch generiert. Im Folgenden werden die wesentlichen Schritte zum eigenen Service durchlaufen:

1. Stellen Sie sicher, dass InterBase auf Ihrem System läuft. Rufen Sie dazu den InterBase Server Manager über das Start-Kommando auf.

2. Starten Sie den RAD Server (Developer Instance) mit dem Befehl EMSDevServer auf der Kommandozeile. Beim ersten Start müssen Sie den Assistenten zur Einrichtung des Servers durchlaufen. Das Dialogfeld ergänzen Sie unter Serverinstanz entsprechend den Eingaben in Abbildung 5. Die weiteren Schritte des Assistenten können Sie ohne Anpassungen übernehmen und den Entwicklungsserver auf diese Weise konfigurieren. Nach Abschluss erscheint ein Dialogfeld, das es erlaubt, den Server zu starten bzw. zu stoppen, die Serveradresse im Browser aufzurufen und die Konsole zu aktivieren.

3. Klicken Sie auf den Button Browser öffnen, und der Standardinternetbrowser des Systems wird geöffnet. Der Entwicklungsserver ist unter localhost auf Port 8080 zu erreichen. Rufen Sie den Endpunkt localhost:8080/version im Browser auf, um eine Statusmeldung des Servers zu produzieren (Abb. 6).

Jetzt wollen wir eine eigene Ressource als RESTful Service bereitstellen. Dafür sind nur wenige Schritte notwendig:

Abb. 5: Konfiguration des RAD Servers auf dem Entwicklungsrechner

1. Starten Sie RAD Studio und legen Sie ein neues Projekt an. Wählen Sie als Projekttyp RAD Server(EMS)-Package (Abb. 7).

2. Durchlaufen Sie den Assistenten und nehmen Sie die Einstellungen vor, die Sie in Abbildung 8 sehen. Legen Sie ein Package mit einer Ressource an. In dieser Ressource werden dann die HTTP-Methoden GET, POST usw. implementiert.

3. Zur Auswahl als Ressource steht ein Datenmodul oder eine Unit. In einer Unit kann zum Beispiel Businesslogik hinterlegt werden. Hier ist es auch möglich, Quellcode aus vorhanden Delphi/C++-Projekten zu übernehmen. Vergeben Sie einen Namen für die Ressource, der später Bestandteil des Endpunkts ist.

4. Im folgenden Schritt müssen die gewünschten Methoden am Endpunkt definiert werden, z. B. eine GET-Methode, um Daten abzurufen.

5. Beenden Sie den Dialog und RAD Studio generiert den notwendigen Quellcode.

Den Quellcode sehen wir uns jetzt noch etwas genauer an. Die Projektstruktur zeigt, dass die Ressource, hier mit dem Namen MyService, als Unit implementiert wird (Listing 4).

Abb. 7: Auswahl der Projektvorlage

Abb. 8: Assistent zum Anlegen einer neuen REST-Ressource

Listing 4: Ein RESTful API mit RAD Server

unit service;
interface
uses
  System.SysUtils, System.Classes, System.JSON,
  EMS.Services, EMS.ResourceAPI,
  EMS.ResourceTypes;
type
  [ResourceName('MyService')]
  {$METHODINFO ON}
  TMyServiceResource = class
  published
    procedure Get(const AContext: TEndpointContext; const ARequest: TEndpointRequest; const AResponse: TEndpointResponse);
  end;
  {$METHODINFO OFF}
implementation
procedure TMyServiceResource.GET(const AContext: TEndpointContext; const ARequest: TEndpointRequest; const AResponse: TEndpointResponse);
begin
  // Sample code
  AResponse.Body.SetValue(TJSONString.Create('MyService'), True)
end;
 
procedure Register;
begin
  RegisterResource(TypeInfo(TMyServiceResource));
end;
 
initialization
  Register;
end.

Letztendlich entscheidend ist die Definition der Procedure TMyServiceResource.GET, in der die Implementierung der HTTP-Methode GET für das API stattfindet. Wir geben als Antwort lediglich einen JSON-Datenstrom mit einer einzigen Zeichenkette (‚MyService‘) zurück. An dieser Stelle müsste in Produktionsprojekten der Code hinterlegt werden, der bei Empfang einer GET-Message vom Server ausgeführt werden soll.

Ob die Ressource via REST von außen erreichbar ist, kann man schnell testen. Starten Sie dazu das aktive Projekt in RAD Studio, und die Ressource wird über den Entwicklungsserver bereitgestellt. Wechseln Sie zum Browser und rufen Sie nun den Endpunkt unter localhost:8080/MyService auf (Abb. 9). Andere HTTP-Methoden (POST, DELETE usw.) sind auf die gleiche Art und Weise zu implementieren. Es genügt als Einstiegspunkt jeweils eine eigene Procedure, in deren Rumpf der zu verarbeitende Code hinterlegt wird. Über vorgefertigte Bibliotheken ist es leicht möglich, die zu sendenden Daten als allgemein gebräuchlichen JSON-Datenstrom zu übermitteln. Die Nutzung des Development-Servers auf dem lokalen Rechner ist natürlich nur während der Entwicklung möglich. Für eine Produktionsumgebung sollten Sie den EMS-Server und den EMS-Konsolenserver auf einem Webserver einrichten. Aktuell werden Microsoft IIS Server (Windows) und Apache Server (Windows, Linux) unterstützt.

Fassen wir zusammen: Ein eigenes API anzubieten ist heute kaum schwieriger, als eine Webseite aufzusetzen. Entweder Sie programmieren es von Hand, zum Beispiel mit Node. js, Express und JavaScript, oder Sie nutzen eine integrierte Entwicklungsumgebung mit entsprechender Funktion. Programmfunktionen via REST zur Nutzung zur Verfügung zu stellen, ist ein Schritt dahin, eine monolithische Anwendungsstruktur in eine Microservices-Architektur umzubauen. Es ist der Weg hin zu modern strukturierten Applikationen. Als API bereitgestellte Services auf der Basis von REST können von Clients beliebiger Systeme und von unterschiedlichsten Gerätekategorien genutzt werden.

Fazit

Was haben die Unternehmen bzw. Dienste Wikipedia, Google Maps, Facebook, Twitter, PayPal und DHL gemeinsam? Richtig, sie bieten alle eine generisch nutzbare Programmierschnittstelle in Form eines API. Damit kann man die speziellen Funktionen und Services in die eigene Anwendung, App oder Webapplikation einbinden. Viele Services sind bis zu einem bestimmten Nutzungsgrad kostenfrei. Nutzen Sie diese Möglichkeit, um Ihre Apps funktional aufzuwerten. Einen Schritt weiter geht man, wenn man sich vom Konsumenten zum Anbieter entwickeln möchte. Bereits mit überschaubarem Aufwand ist das erste eigene API online und steht der Entwicklercommunity zur Verfügung.

Weitere Informationen zu diesen und anderen Themen der IT finden Sie unter http://larinet.com.